package com.sg.service.biz.app.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.*;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.calc.CalculateSubtractionOfTwoNumServiceComReqDto;
import com.sg.dto.integration.calc.CalculateSubtractionOfTwoNumServiceComRespDto;
import com.sg.service.biz.app.*;
import com.sg.common.exception.Assert;
import com.wicket.okrapp.dal.po.mbg.*;
import com.wicket.okrcalc.integration.FwCalcCalculationRulesClient;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class ResetCheckItemStateServiceImpl
        implements com.wicket.okrapp.biz.service.ResetCheckItemStateService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
    @Resource
    private MOmsTargetObjectiveService mOmsTargetObjectiveService;
    //@Resource
    //private undefinedService undefinedService;
    @Resource
    private OffStateService offStateService;
    @Resource
    private TargetContentService targetContentService;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private NbResetCheckItemState nbResetCheckItemState;
    @Resource
    private MOmsBizAppStatusCheckItemService mOmsBizAppStatusCheckItemService;
    @Resource
    private MOmsAssistCheckPanelUpdateService mOmsAssistCheckPanelUpdateService;
    @Resource
    private FwCalcCalculationRulesClient fwCalcCalculationRulesClient;
    @Resource
    private MOmsAssistNodeStatusService mOmsAssistNodeStatusService;
    @Resource
    private ExecuteProgressService executeProgressService;
    @Resource
    private ProgressPublicTechnicaCapacityService progressPublicTechnicaCapacityService;
    @Resource
    private MOmsTargetCategoryService mOmsTargetCategoryService;
    @Resource
    private IndexSystemService indexSystemService;
    @Resource
    private MOmsTaskService mOmsTaskService;

    /**
     * D3执行循环补偿改目标重置下级检查项状态(公共)[6628]
     * gen by moon at 5/19/2023, 6:45:09 AM
     */
    @Trace(operationName = "D3执行循环补偿改目标重置下级检查项状态(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementLoopOffsetUpdateTargetResetCheckItemStateComRespDto implementLoopOffsetUpdateTargetResetCheckItemStateCom(ImplementLoopOffsetUpdateTargetResetCheckItemStateComReqDto reqDto) {


        //virtualUsage 3-2-09查重置下级检查项状态定时任务调度列表  41494
        List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch = new ArrayList<>();
        QueryTimerTaskPlanListReq queryTimerTaskPlanListReq = new QueryTimerTaskPlanListReq();
        queryTimerTaskPlanListReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:933581_1_41494
        queryTimerTaskPlanListReq.setDispatchActionTypeCode("DISPATCH_DOWNWARD_UPDATE_TARGET_SET_CHECK_ITEM_ETC_STATE");//sourceId:933582_1_41494
        queryTimerTaskPlanListReq.setIsComplete("FALSE");//sourceId:933585_1_41494
        queryTimerTaskPlanListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:933586_1_41494
        if (reqDto != null) {
            queryTimerTaskPlanListReq.setAddRuleInfoId(reqDto.getAddRuleInfoId());//SimpleFieldAssign//sourceId:933697_1_41494
            queryTimerTaskPlanListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933584_1_41494
        }

        /*3-2-09查重置下级检查项状态定时任务调度列表[3261]   */
        Assert.isNull(queryTimerTaskPlanListReq.getTaskDispatchTypeCode(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-任务调度类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getDispatchActionTypeCode(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-任务调度的行为类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getAddRuleInfoId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-生成辅助规则信息值不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getThemeContentId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-主题内容ID不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getIsComplete(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-是否执行完成不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getSpaceId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-创建于空间ID不能为空", false);
        listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanList(queryTimerTaskPlanListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch.size() > 0)) {
            //if(3-2-09查重置下级检查项状态定时任务调度列表.定时任务调度列表数据集条数 大于 0)  41495

//ModelCode: circulationCollections
            for (OmsTargetTimingTaskDispatch circulationCollectionsRes : listOmsTargetTimingTaskDispatch) {

                OmsTargetObjective omsTargetObjective = null;
                QueryTargetObjDetailReq queryTargetObjDetailReq = new QueryTargetObjDetailReq();
                queryTargetObjDetailReq.setIsArchive("FALSE");//sourceId:933618_1_41499
                if (circulationCollectionsRes != null) {
                    queryTargetObjDetailReq.setObjectiveId(circulationCollectionsRes.getObjectId());//SimpleFieldAssign//sourceId:933606_1_41499
                }
                if (reqDto != null) {
                    queryTargetObjDetailReq.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933652_1_41499
                }

                /*3-3-03查当前指标[2697]   */
                Assert.isNull(queryTargetObjDetailReq.getObjectiveId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-3-03查当前指标-指标ID不能为空", false);
                Assert.isNull(queryTargetObjDetailReq.getEvaluationTemplateId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-3-03查当前指标-冗余评价模板ID不能为空", false);
                Assert.isNull(queryTargetObjDetailReq.getIsArchive(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-3-03查当前指标-是否存档不能为空", false);
                omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((!(omsTargetObjective != null && omsTargetObjective.getTargetValueType() != null && omsTargetObjective.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE")))) {
                    //if(3-3-03查当前指标.冗余指标业务类型 不等于 主观定性)  41500

                    ImplementResetSubordinateManyCheckItemStateComRespDto implementResetSubordinateManyCheckItemStateComRespDto = null;
                    if (omsTargetObjective != null) {
                        ImplementResetSubordinateManyCheckItemStateComReqDto implementResetSubordinateManyCheckItemStateComReqDto = new ImplementResetSubordinateManyCheckItemStateComReqDto();
                        implementResetSubordinateManyCheckItemStateComReqDto.setCustomField("UPDTAE_TARGET_VALUE");//CUSTOM_CONVENTION//sourceId:933661_1_41501
                        if (omsTargetObjective != null) {
                            implementResetSubordinateManyCheckItemStateComReqDto.setTargetCycleContentId(omsTargetObjective.getObjectiveId());//SimpleFieldAssign//sourceId:958491_1_41501
                            implementResetSubordinateManyCheckItemStateComReqDto.setComCode(omsTargetObjective.getObjectiveCode());//SimpleFieldAssign//sourceId:933658_1_41501
                        }
                        if (reqDto != null) {
                            implementResetSubordinateManyCheckItemStateComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933659_1_41501
                        }

                        /*D3向下打开指标目标设置等检查项状态[5929]   */
                        Assert.isNull(implementResetSubordinateManyCheckItemStateComReqDto.getCustomField(), "D3执行循环补偿改目标重置下级检查项状态(公共)-D3向下打开指标目标设置等检查项状态-业务操作行为类型不能为空", false);
                        Assert.isNull(implementResetSubordinateManyCheckItemStateComReqDto.getTargetCycleContentId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-D3向下打开指标目标设置等检查项状态-关联目标内容ID不能为空", false);
                        Assert.isNull(implementResetSubordinateManyCheckItemStateComReqDto.getComCode(), "D3执行循环补偿改目标重置下级检查项状态(公共)-D3向下打开指标目标设置等检查项状态-通用编码标识不能为空", false);
                        Assert.isNull(implementResetSubordinateManyCheckItemStateComReqDto.getEvaluationTemplateId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-D3向下打开指标目标设置等检查项状态-冗余评价模板ID不能为空", false);
                        implementResetSubordinateManyCheckItemStateComRespDto = offStateService.implementResetSubordinateManyCheckItemStateCom(implementResetSubordinateManyCheckItemStateComReqDto)/*vcase invoke isSameApp*/;


                    }
                    OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
                    QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq = new QueryTimerTaskPlanDetailReq();
                    if (circulationCollectionsRes != null) {
                        queryTimerTaskPlanDetailReq.setTimingTaskDispatchId(circulationCollectionsRes.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:933759_1_41510
                    }
                    if (reqDto != null) {
                        queryTimerTaskPlanDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933760_1_41510
                    }

                    /*3-2-09查定时任务调度（判断是否完成）[3187]   */
                    Assert.isNull(queryTimerTaskPlanDetailReq.getTimingTaskDispatchId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查定时任务调度（判断是否完成）-定时任务调度记录ID不能为空", false);
                    Assert.isNull(queryTimerTaskPlanDetailReq.getThemeContentId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查定时任务调度（判断是否完成）-主题内容ID不能为空", false);
                    omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                    if ((omsTargetTimingTaskDispatch != null && omsTargetTimingTaskDispatch.getIsComplete() != null && omsTargetTimingTaskDispatch.getIsComplete().equals("TRUE"))) {
                        //if(3-2-09查定时任务调度（判断是否完成）.是否执行完成 等于 是)  41511

//processBranchName:继续循环 ,processBranchId:41512
                        continue;
                    }
                    AddUnifyMgtDeptOrderSetWeightOrTargetValueComRespDto addUnifyMgtDeptOrderSetWeightOrTargetValueComRespDto = null;
                    if (omsTargetObjective != null) {
                        AddUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto = new AddUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto();
                        if (omsTargetObjective != null) {
                            addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setObjectiveId(omsTargetObjective.getObjectiveId());//SimpleFieldAssign//sourceId:933662_1_41502
                            addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setObjectiveCode(omsTargetObjective.getObjectiveCode());//SimpleFieldAssign//sourceId:933663_1_41502
                            addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setTargetId(omsTargetObjective.getTargetId());//SimpleFieldAssign//sourceId:933667_1_41502
                        }
                        if (reqDto != null) {
                            addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933664_1_41502
                            addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:933666_1_41502
                        }
                        if (circulationCollectionsRes != null) {
                            addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setContentId(circulationCollectionsRes.getStandbyField1());//SimpleFieldAssign//sourceId:933665_1_41502
                        }

                        /*D3新增统一管理部门命令-设权重或目标值(公共)[6359]   */
                        Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getObjectiveId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-指标ID不能为空", false);
                        Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getObjectiveCode(), "D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-指标标识不能为空", false);
                        Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getTargetId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-冗余目标ID不能为空", false);
                        Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getEvaluationTemplateId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-冗余评价模板ID不能为空", false);
                        Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getBatchCode(), "D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-统一管理批次批次标识不能为空", false);
                        addUnifyMgtDeptOrderSetWeightOrTargetValueComRespDto = targetContentService.addUnifyMgtDeptOrderSetWeightOrTargetValueCom(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto)/*vcase invoke isSameApp*/;


                    }
                    boolean bOOLEAN;
                    OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch_2 = new OmsTargetTimingTaskDispatch();
                    omsTargetTimingTaskDispatch_2.setIsComplete("TRUE");//sourceId:933669_1_41513
                    omsTargetTimingTaskDispatch_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:933673_1_41513
                    omsTargetTimingTaskDispatch_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:933670_1_41513
                    if (circulationCollectionsRes != null) {
                        omsTargetTimingTaskDispatch_2.setTimingTaskDispatchId(circulationCollectionsRes.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:933668_1_41513
                    }

                    /*3-2-09更新定时任务调度（已完成）[3186]   */
                    Assert.isNull(omsTargetTimingTaskDispatch_2.getTimingTaskDispatchId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09更新定时任务调度（已完成）-定时任务调度记录ID不能为空", false);
                    Assert.isNull(omsTargetTimingTaskDispatch_2.getIsComplete(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09更新定时任务调度（已完成）-是否执行完成不能为空", false);
                    Assert.isNull(omsTargetTimingTaskDispatch_2.getOperationInductionId(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09更新定时任务调度（已完成）-操作人就职记录ID不能为空", false);
                    Assert.isNull(omsTargetTimingTaskDispatch_2.getOperateTime(), "D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09更新定时任务调度（已完成）-操作时间不能为空", false);
                    bOOLEAN = mOmsTargetTimingTaskDispatchService.refreshTimerTaskPlan(omsTargetTimingTaskDispatch_2)/*vcase invoke 本地 method 方法调用;*/;


                }
//ModelCode: circulationEnd
            }

        }
        ImplementLoopOffsetUpdateTargetResetCheckItemStateComRespDto retData = new ImplementLoopOffsetUpdateTargetResetCheckItemStateComRespDto();


        return retData;
    }

    /**
     * D3执行分析指标操作主体信息(公共)[6641]
     * gen by moon at 5/14/2023, 3:01:18 AM
     */
    @Trace(operationName = "D3执行分析指标操作主体信息(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalyseObjtiveOpeBodyInfoComRespDto implementAnalyseObjtiveOpeBodyInfoCom(ImplementAnalyseObjtiveOpeBodyInfoComReqDto reqDto) {


        ImplementAcceptFieldRespDto receptionServiceRes_3 = null;
        if ((reqDto != null && reqDto.getLevelNumber() != null && reqDto != null && reqDto.getLevelNumber() == 1L)) {
            //if((D3执行分析指标操作主体信息(公共).层级 值不等于空  and D3执行分析指标操作主体信息(公共).层级 等于 1))  41554

//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes = null;
            ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
            receptionServiceReq.setAddRuleInfoTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:935503_1_41555
            if (reqDto != null) {
                receptionServiceReq.setAddRuleInfoId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:935504_1_41555
            }

            /*M3约定：评价模板[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getAddRuleInfoTypeCode(), "D3执行分析指标操作主体信息(公共)-M3约定：评价模板-生成规则信息类型编码不能为空", false);
            Assert.isNull(receptionServiceReq.getAddRuleInfoId(), "D3执行分析指标操作主体信息(公共)-M3约定：评价模板-生成辅助规则信息值不能为空", false);
            receptionServiceRes = nbResetCheckItemState.implementAcceptField(receptionServiceReq);


//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
            ImplementAcceptFieldReqDto receptionServiceReq_1 = new ImplementAcceptFieldReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setAddRuleInfoTypeCode(receptionServiceRes.getAddRuleInfoTypeCode());//SimpleFieldAssign//sourceId:935515_1_41556
                receptionServiceReq_1.setAddRuleInfoId(receptionServiceRes.getAddRuleInfoId());//SimpleFieldAssign//sourceId:935516_1_41556
            }

            /*M3接收上文出参字段[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getAddRuleInfoTypeCode(), "D3执行分析指标操作主体信息(公共)-M3接收上文出参字段-生成规则信息类型编码不能为空", false);
            Assert.isNull(receptionServiceReq_1.getAddRuleInfoId(), "D3执行分析指标操作主体信息(公共)-M3接收上文出参字段-生成辅助规则信息值不能为空", false);
            receptionServiceRes_2 = nbResetCheckItemState.implementAcceptField(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getLevelNumber() != null && reqDto != null && reqDto.getLevelNumber() > 1L)) {
            //elseif((D3执行分析指标操作主体信息(公共).层级 值不等于空  and D3执行分析指标操作主体信息(公共).层级 大于 1))  41557

//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_4 = null;
            ImplementAcceptFieldReqDto receptionServiceReq_2 = new ImplementAcceptFieldReqDto();
            receptionServiceReq_2.setAddRuleInfoTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:935509_1_41558
            if (reqDto != null) {
                receptionServiceReq_2.setAddRuleInfoId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:935510_1_41558
            }

            /*M3约定：被评对象目标周期[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getAddRuleInfoTypeCode(), "D3执行分析指标操作主体信息(公共)-M3约定：被评对象目标周期-生成规则信息类型编码不能为空", false);
            Assert.isNull(receptionServiceReq_2.getAddRuleInfoId(), "D3执行分析指标操作主体信息(公共)-M3约定：被评对象目标周期-生成辅助规则信息值不能为空", false);
            receptionServiceRes_4 = nbResetCheckItemState.implementAcceptField(receptionServiceReq_2);


//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_6 = null;
            ImplementAcceptFieldReqDto receptionServiceReq_3 = new ImplementAcceptFieldReqDto();
            if (receptionServiceRes_4 != null) {
                receptionServiceReq_3.setAddRuleInfoTypeCode(receptionServiceRes_4.getAddRuleInfoTypeCode());//SimpleFieldAssign//sourceId:935515_1_41559
                receptionServiceReq_3.setAddRuleInfoId(receptionServiceRes_4.getAddRuleInfoId());//SimpleFieldAssign//sourceId:935516_1_41559
            }

            /*M3接收上文出参字段[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getAddRuleInfoTypeCode(), "D3执行分析指标操作主体信息(公共)-M3接收上文出参字段-生成规则信息类型编码不能为空", false);
            Assert.isNull(receptionServiceReq_3.getAddRuleInfoId(), "D3执行分析指标操作主体信息(公共)-M3接收上文出参字段-生成辅助规则信息值不能为空", false);
            receptionServiceRes_6 = nbResetCheckItemState.implementAcceptField(receptionServiceReq_3);


            receptionServiceRes_3 = receptionServiceRes_6;
        }
        ImplementAnalyseObjtiveOpeBodyInfoComRespDto retData = new ImplementAnalyseObjtiveOpeBodyInfoComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setAddRuleInfoTypeCode(receptionServiceRes_3.getAddRuleInfoTypeCode());//SimpleFieldAssign//sourceId:935517_1
            retData.setAddRuleInfoId(receptionServiceRes_3.getAddRuleInfoId());//SimpleFieldAssign//sourceId:935518_1
        }


        return retData;
    }

    /**
     * D3执行撤销批次处理状态检查项更新(公共)[7179]
     * gen by moon at 10/13/2023, 12:06:58 AM
     */
    @Trace(operationName = "D3执行撤销批次处理状态检查项更新(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementUndoBatchHandleCheckItemStateComRespDto implementUndoBatchHandleCheckItemStateCom(ImplementUndoBatchHandleCheckItemStateComReqDto reqDto) {


        if ((reqDto != null && reqDto.getBatchSetObjectType() != null && reqDto.getBatchSetObjectType().equals("TOP_EVA_TEMP_MGT"))) {
            //if(D3执行撤销批次处理状态检查项更新(公共).批次设置对象类型 等于 高层评价模板管理)  48400

            List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem = new ArrayList<>();
            QueryBizAppCheckItemStatListReq queryBizAppCheckItemStatListReq = new QueryBizAppCheckItemStatListReq();
            queryBizAppCheckItemStatListReq.setIsComplete("FALSE");//sourceId:1118168_1_48402
            if (reqDto != null) {
                queryBizAppCheckItemStatListReq.setEntityId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1118167_1_48402
                queryBizAppCheckItemStatListReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118172_1_48402
            }

            /*3-11-04查业务应用校验项状态列表[2768]   */
            Assert.isNull(queryBizAppCheckItemStatListReq.getEntityId(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-内容对象实例ID不能为空", false);
            Assert.isNull(queryBizAppCheckItemStatListReq.getThemeContentId(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-主题内容ID不能为空", false);
            Assert.isNull(queryBizAppCheckItemStatListReq.getIsComplete(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-是否已完成不能为空", false);
            listOmsBizAppStatusCheckItem = mOmsBizAppStatusCheckItemService.queryBizAppCheckItemStatList(queryBizAppCheckItemStatListReq)/*vcase invoke 本地 method 方法调用;*/;


            boolean bOOLEAN;
            if (listOmsBizAppStatusCheckItem != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem) && listOmsBizAppStatusCheckItem.size() > 0) {
                List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_2 = new ArrayList<>();
                if (listOmsBizAppStatusCheckItem != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem) && listOmsBizAppStatusCheckItem != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem)) {
                    listOmsBizAppStatusCheckItem_2 = //objList-to-objLists
                            listOmsBizAppStatusCheckItem.stream().map(item -> {
                                OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
                                elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_48403
                                elm.setIsComplete("TRUE");//sourceId:218938_2_48403
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_48403
                }

                /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

                bOOLEAN = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_2)/*vcase invoke 本地 method 方法调用;*/;


            }
            List<OmsTargetCategory> listOmsTargetCategory = new ArrayList<>();
            QueryTargetCatListReq queryTargetCatListReq = new QueryTargetCatListReq();
            queryTargetCatListReq.setIsArchive("FALSE");//sourceId:1118196_1_48404
            if (reqDto != null) {
                queryTargetCatListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118195_1_48404
            }

            /*3-3-02查模板下目标分类列表[2592]   */
            Assert.isNull(queryTargetCatListReq.getEvaluationTemplateId(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-02查模板下目标分类列表-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetCatListReq.getIsArchive(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-02查模板下目标分类列表-是否存档不能为空", false);
            listOmsTargetCategory = mOmsTargetCategoryService.queryTargetCatList(queryTargetCatListReq)/*vcase invoke 本地 method 方法调用;*/;


            List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_3 = new ArrayList<>();
            if (listOmsTargetCategory != null && !CollectionUtil.isEmpty(listOmsTargetCategory) && listOmsTargetCategory.size() > 0) {
                BatchQueryBizAppCheckItemStatReq batchQueryBizAppCheckItemStatReq = new BatchQueryBizAppCheckItemStatReq();
                batchQueryBizAppCheckItemStatReq.setIsComplete("FALSE");//sourceId:1118202_1_48405
                if (listOmsTargetCategory != null && !CollectionUtil.isEmpty(listOmsTargetCategory) && listOmsTargetCategory != null && !CollectionUtil.isEmpty(listOmsTargetCategory)) {
                    batchQueryBizAppCheckItemStatReq.setBizAppCheckItemStatList(listOmsTargetCategory.stream().map(item -> item.getTargetCategoryId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:1118198_1_48405
                }
                if (reqDto != null) {
                    batchQueryBizAppCheckItemStatReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118204_1_48405
                }

                /*3-11-04批量查业务应用校验项状态[2769]   */
                Assert.isNull(batchQueryBizAppCheckItemStatReq.getIsComplete(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-是否已完成不能为空", false);
                Assert.isNull(batchQueryBizAppCheckItemStatReq.getThemeContentId(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-主题内容ID不能为空", false);
                listOmsBizAppStatusCheckItem_3 = mOmsBizAppStatusCheckItemService.batchQueryBizAppCheckItemStat(batchQueryBizAppCheckItemStatReq)/*vcase invoke 本地 method 方法调用;*/;


            }
            boolean bOOLEAN_1;
            if (listOmsBizAppStatusCheckItem_3 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_3) && listOmsBizAppStatusCheckItem_3.size() > 0) {
                List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_5 = new ArrayList<>();
                if (listOmsBizAppStatusCheckItem_3 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_3) && listOmsBizAppStatusCheckItem_3 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_3)) {
                    listOmsBizAppStatusCheckItem_5 = //objList-to-objLists
                            listOmsBizAppStatusCheckItem_3.stream().map(item -> {
                                OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
                                elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_48406
                                elm.setIsComplete("TRUE");//sourceId:218938_2_48406
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_48406
                }

                /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

                bOOLEAN_1 = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_5)/*vcase invoke 本地 method 方法调用;*/;


            }
            List<OmsTargetObjective> listOmsTargetObjective = new ArrayList<>();
            QueryTargetObjListReq queryTargetObjListReq = new QueryTargetObjListReq();
            queryTargetObjListReq.setLevelNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1118224_1_48407
            queryTargetObjListReq.setIsArchive("FALSE");//sourceId:1118226_1_48407
            if (reqDto != null) {
                queryTargetObjListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118225_1_48407
            }

            /*3-3-03查指标列表[2692]   */
            Assert.isNull(queryTargetObjListReq.getEvaluationTemplateId(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-03查指标列表-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetObjListReq.getLevelNumber(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-03查指标列表-层级不能为空", false);
            Assert.isNull(queryTargetObjListReq.getIsArchive(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-03查指标列表-是否存档不能为空", false);
            listOmsTargetObjective = mOmsTargetObjectiveService.queryTargetObjList(queryTargetObjListReq)/*vcase invoke 本地 method 方法调用;*/;


            List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_6 = new ArrayList<>();
            if (listOmsTargetObjective != null && !CollectionUtil.isEmpty(listOmsTargetObjective) && listOmsTargetObjective.size() > 0) {
                BatchQueryBizAppCheckItemStatReq batchQueryBizAppCheckItemStatReq_1 = new BatchQueryBizAppCheckItemStatReq();
                batchQueryBizAppCheckItemStatReq_1.setIsComplete("FALSE");//sourceId:1118202_1_48408
                if (listOmsTargetObjective != null && !CollectionUtil.isEmpty(listOmsTargetObjective) && listOmsTargetObjective != null && !CollectionUtil.isEmpty(listOmsTargetObjective)) {
                    batchQueryBizAppCheckItemStatReq_1.setBizAppCheckItemStatList(listOmsTargetObjective.stream().map(item -> item.getObjectiveId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:1118198_1_48408
                }
                if (reqDto != null) {
                    batchQueryBizAppCheckItemStatReq_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118204_1_48408
                }

                /*3-11-04批量查业务应用校验项状态[2769]   */
                Assert.isNull(batchQueryBizAppCheckItemStatReq_1.getIsComplete(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-是否已完成不能为空", false);
                Assert.isNull(batchQueryBizAppCheckItemStatReq_1.getThemeContentId(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-主题内容ID不能为空", false);
                listOmsBizAppStatusCheckItem_6 = mOmsBizAppStatusCheckItemService.batchQueryBizAppCheckItemStat(batchQueryBizAppCheckItemStatReq_1)/*vcase invoke 本地 method 方法调用;*/;


            }
            boolean bOOLEAN_2;
            if (listOmsBizAppStatusCheckItem_6 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_6) && listOmsBizAppStatusCheckItem_6.size() > 0) {
                List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_7 = new ArrayList<>();
                if (listOmsBizAppStatusCheckItem_6 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_6) && listOmsBizAppStatusCheckItem_6 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_6)) {
                    listOmsBizAppStatusCheckItem_7 = //objList-to-objLists
                            listOmsBizAppStatusCheckItem_6.stream().map(item -> {
                                OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
                                elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_48409
                                elm.setIsComplete("TRUE");//sourceId:218938_2_48409
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_48409
                }

                /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

                bOOLEAN_2 = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_7)/*vcase invoke 本地 method 方法调用;*/;


            }
            List<OmsTargetCategory> listOmsTargetCategory_2 = new ArrayList<>();
            QueryTargetCatListReq queryTargetCatListReq_1 = new QueryTargetCatListReq();
            queryTargetCatListReq_1.setIsLast("TRUE");//sourceId:1171379_1_49960
            queryTargetCatListReq_1.setIsArchive("FALSE");//sourceId:1171377_1_49960
            if (reqDto != null) {
                queryTargetCatListReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1171376_1_49960
            }

            /*3-3-02查末级目标分类列表[2592]   */
            Assert.isNull(queryTargetCatListReq_1.getEvaluationTemplateId(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-02查末级目标分类列表-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetCatListReq_1.getIsLast(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-02查末级目标分类列表-目标分类是否末级不能为空", false);
            Assert.isNull(queryTargetCatListReq_1.getIsArchive(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-02查末级目标分类列表-是否存档不能为空", false);
            listOmsTargetCategory_2 = mOmsTargetCategoryService.queryTargetCatList(queryTargetCatListReq_1)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: circulationCollections
            for (OmsTargetCategory circulationCollectionsRes : listOmsTargetCategory_2) {

                ImplementAmendSuperiorDashBoardComRespDto implementAmendSuperiorDashBoardComRespDto = null;
                ImplementAmendSuperiorDashBoardComReqDto implementAmendSuperiorDashBoardComReqDto = new ImplementAmendSuperiorDashBoardComReqDto();
                implementAmendSuperiorDashBoardComReqDto.setCheckItemCode("OBJECTIVE_STANDARD_SET_CHECK_ITEM");//CUSTOM_CONVENTION//sourceId:1171387_1_49959
                implementAmendSuperiorDashBoardComReqDto.setCheckObjectTypeCode("OMS_TARGET_CATEGORY");//sourceId:1171390_1_49959
                implementAmendSuperiorDashBoardComReqDto.setObjectTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:1171394_1_49959
                implementAmendSuperiorDashBoardComReqDto.setEmploySceneTypeCode("USED_TARGET_CONTNET_SET");//sourceId:1171393_1_49959
                if (circulationCollectionsRes != null) {
                    implementAmendSuperiorDashBoardComReqDto.setCheckObjectTypeId(circulationCollectionsRes.getTargetCategoryId());//SimpleFieldAssign//sourceId:1171388_1_49959
                }
                if (reqDto != null) {
                    implementAmendSuperiorDashBoardComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1171391_1_49959
                }

                /*D3执行修正上级仪表盘(公共)[6500]   */
                Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getCheckItemCode(), "D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-检查项标识不能为空", false);
                Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getCheckObjectTypeCode(), "D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-检查内容对象类型编码不能为空", false);
                Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getCheckObjectTypeId(), "D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-检查内容对象ID 不能为空", false);
                Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getObjectTypeCode(), "D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-内容对象类型编码不能为空", false);
                Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getEmploySceneTypeCode(), "D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-使用场景编码不能为空", false);
                Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getThemeContentId(), "D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-主题内容ID不能为空", false);
                implementAmendSuperiorDashBoardComRespDto = offStateService.implementAmendSuperiorDashBoardCom(implementAmendSuperiorDashBoardComReqDto)/*vcase invoke isSameApp*/;


//ModelCode: circulationEnd
            }

        } else if ((reqDto != null && reqDto.getBatchSetObjectType() != null && reqDto.getBatchSetObjectType().equals("BASIC_DIV_MGT") || reqDto != null && reqDto.getBatchSetObjectType() != null && reqDto.getBatchSetObjectType().equals("MID_DIV_MGT"))) {
            //elseif((D3执行撤销批次处理状态检查项更新(公共).批次设置对象类型 等于 基层分工管理 or D3执行撤销批次处理状态检查项更新(公共).批次设置对象类型 等于 中层分工管理))  48401

            List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_8 = new ArrayList<>();
            QueryBizAppCheckItemStatListReq queryBizAppCheckItemStatListReq_1 = new QueryBizAppCheckItemStatListReq();
            queryBizAppCheckItemStatListReq_1.setIsComplete("FALSE");//sourceId:1118168_1_48410
            if (reqDto != null) {
                queryBizAppCheckItemStatListReq_1.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1118167_1_48410
                queryBizAppCheckItemStatListReq_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118172_1_48410
            }

            /*3-11-04查业务应用校验项状态列表[2768]   */
            Assert.isNull(queryBizAppCheckItemStatListReq_1.getEntityId(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-内容对象实例ID不能为空", false);
            Assert.isNull(queryBizAppCheckItemStatListReq_1.getThemeContentId(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-主题内容ID不能为空", false);
            Assert.isNull(queryBizAppCheckItemStatListReq_1.getIsComplete(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-是否已完成不能为空", false);
            listOmsBizAppStatusCheckItem_8 = mOmsBizAppStatusCheckItemService.queryBizAppCheckItemStatList(queryBizAppCheckItemStatListReq_1)/*vcase invoke 本地 method 方法调用;*/;


            boolean bOOLEAN_3;
            if (listOmsBizAppStatusCheckItem_8 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_8) && listOmsBizAppStatusCheckItem_8.size() > 0) {
                List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_9 = new ArrayList<>();
                if (listOmsBizAppStatusCheckItem_8 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_8) && listOmsBizAppStatusCheckItem_8 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_8)) {
                    listOmsBizAppStatusCheckItem_9 = //objList-to-objLists
                            listOmsBizAppStatusCheckItem_8.stream().map(item -> {
                                OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
                                elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_48411
                                elm.setIsComplete("TRUE");//sourceId:218938_2_48411
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_48411
                }

                /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

                bOOLEAN_3 = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_9)/*vcase invoke 本地 method 方法调用;*/;


            }
            QueryDeptOrUcdTargetListComRespDto queryDeptOrUcdTargetListComRespDto = null;
            QueryDeptOrUcdTargetListComReqDto queryDeptOrUcdTargetListComReqDto = new QueryDeptOrUcdTargetListComReqDto();
            queryDeptOrUcdTargetListComReqDto.setCustomField("0");//CUSTOM_CONVENTION//sourceId:1118231_1_48412
            if (reqDto != null) {
                queryDeptOrUcdTargetListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1118228_1_48412
                queryDeptOrUcdTargetListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118230_1_48412
            }

            /*D3查询部门或UCD牵头目标列表(公共)[3938]   */
            Assert.isNull(queryDeptOrUcdTargetListComReqDto.getDeptId(), "D3执行撤销批次处理状态检查项更新(公共)-D3查询部门或UCD牵头目标列表(公共)-部门ID不能为空", false);
            Assert.isNull(queryDeptOrUcdTargetListComReqDto.getEvaluationTemplateId(), "D3执行撤销批次处理状态检查项更新(公共)-D3查询部门或UCD牵头目标列表(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(queryDeptOrUcdTargetListComReqDto.getCustomField(), "D3执行撤销批次处理状态检查项更新(公共)-D3查询部门或UCD牵头目标列表(公共)-自定义字段不能为空", false);
            queryDeptOrUcdTargetListComRespDto = indexSystemService.queryDeptOrUcdTargetListCom(queryDeptOrUcdTargetListComReqDto)/*vcase invoke isSameApp*/;


            List<OmsTargetObjective> listOmsTargetObjective_2 = new ArrayList<>();
            if (queryDeptOrUcdTargetListComRespDto != null) {
                BatchQueryTargetObjListReq batchQueryTargetObjListReq = new BatchQueryTargetObjListReq();
                batchQueryTargetObjListReq.setIsArchive("FALSE");//sourceId:1171362_1_49954
                if (queryDeptOrUcdTargetListComRespDto != null) {
                    batchQueryTargetObjListReq.setTargetObjList(queryDeptOrUcdTargetListComRespDto.getDeptOrUserUcdTargetList());//list-field-assign//sourceId:1171360_1_49954
                }
                if (reqDto != null) {
                    batchQueryTargetObjListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1171361_1_49954
                }

                /*3-3-03批量查指标列表[2203]   */
                Assert.isNull(batchQueryTargetObjListReq.getEvaluationTemplateId(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-03批量查指标列表-冗余评价模板ID不能为空", false);
                Assert.isNull(batchQueryTargetObjListReq.getIsArchive(), "D3执行撤销批次处理状态检查项更新(公共)-3-3-03批量查指标列表-是否存档不能为空", false);
                listOmsTargetObjective_2 = mOmsTargetObjectiveService.batchQueryTargetObjList(batchQueryTargetObjListReq)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: circulationCollections
            for (OmsTargetObjective circulationCollectionsRes_2 : listOmsTargetObjective_2) {

                QuerySubordinateMultiLevelIndicatorListComRespDto querySubordinateMultiLevelIndicatorListComRespDto = null;
                QuerySubordinateMultiLevelIndicatorListComReqDto querySubordinateMultiLevelIndicatorListComReqDto = new QuerySubordinateMultiLevelIndicatorListComReqDto();
                querySubordinateMultiLevelIndicatorListComReqDto.setComNumField(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:1171339_1_49953
                if (circulationCollectionsRes_2 != null) {
                    querySubordinateMultiLevelIndicatorListComReqDto.setObjectiveId(circulationCollectionsRes_2.getObjectiveId());//SimpleFieldAssign//sourceId:1171342_1_49953
                    querySubordinateMultiLevelIndicatorListComReqDto.setObjectiveCode(circulationCollectionsRes_2.getObjectiveCode());//SimpleFieldAssign//sourceId:1171340_1_49953
                }
                if (reqDto != null) {
                    querySubordinateMultiLevelIndicatorListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1171341_1_49953
                }

                /*D3查询下级多层级指标列表(公共)[5829]   */
                Assert.isNull(querySubordinateMultiLevelIndicatorListComReqDto.getObjectiveId(), "D3执行撤销批次处理状态检查项更新(公共)-D3查询下级多层级指标列表(公共)-指标ID不能为空", false);
                Assert.isNull(querySubordinateMultiLevelIndicatorListComReqDto.getObjectiveCode(), "D3执行撤销批次处理状态检查项更新(公共)-D3查询下级多层级指标列表(公共)-指标标识不能为空", false);
                Assert.isNull(querySubordinateMultiLevelIndicatorListComReqDto.getEvaluationTemplateId(), "D3执行撤销批次处理状态检查项更新(公共)-D3查询下级多层级指标列表(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(querySubordinateMultiLevelIndicatorListComReqDto.getComNumField(), "D3执行撤销批次处理状态检查项更新(公共)-D3查询下级多层级指标列表(公共)-通用数值字段（整数型）不能为空", false);
                querySubordinateMultiLevelIndicatorListComRespDto = targetContentService.querySubordinateMultiLevelIndicatorListCom(querySubordinateMultiLevelIndicatorListComReqDto)/*vcase invoke isSameApp*/;


                List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_10 = new ArrayList<>();
                if (querySubordinateMultiLevelIndicatorListComRespDto != null) {
                    BatchQueryBizAppCheckItemStatReq batchQueryBizAppCheckItemStatReq_2 = new BatchQueryBizAppCheckItemStatReq();
                    batchQueryBizAppCheckItemStatReq_2.setIsComplete("FALSE");//sourceId:1118202_1_49955
                    if (querySubordinateMultiLevelIndicatorListComRespDto != null && querySubordinateMultiLevelIndicatorListComRespDto.getTargetObjByCodeList() != null && !CollectionUtil.isEmpty(querySubordinateMultiLevelIndicatorListComRespDto.getTargetObjByCodeList())) {
                        batchQueryBizAppCheckItemStatReq_2.setBizAppCheckItemStatList(querySubordinateMultiLevelIndicatorListComRespDto.getTargetObjByCodeList().stream().map(item -> item.getObjectiveId())
                                .collect(Collectors.toList()));/*list-to-strings*///sourceId:1118198_1_49955
                    }
                    if (reqDto != null) {
                        batchQueryBizAppCheckItemStatReq_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118204_1_49955
                    }

                    /*3-11-04批量查业务应用校验项状态[2769]   */
                    Assert.isNull(batchQueryBizAppCheckItemStatReq_2.getIsComplete(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-是否已完成不能为空", false);
                    Assert.isNull(batchQueryBizAppCheckItemStatReq_2.getThemeContentId(), "D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-主题内容ID不能为空", false);
                    listOmsBizAppStatusCheckItem_10 = mOmsBizAppStatusCheckItemService.batchQueryBizAppCheckItemStat(batchQueryBizAppCheckItemStatReq_2)/*vcase invoke 本地 method 方法调用;*/;


                }
                boolean bOOLEAN_4;
                if (listOmsBizAppStatusCheckItem_10 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_10) && listOmsBizAppStatusCheckItem_10.size() > 0) {
                    List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_11 = new ArrayList<>();
                    if (listOmsBizAppStatusCheckItem_10 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_10) && listOmsBizAppStatusCheckItem_10 != null && !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_10)) {
                        listOmsBizAppStatusCheckItem_11 = //objList-to-objLists
                                listOmsBizAppStatusCheckItem_10.stream().map(item -> {
                                    OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
                                    elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_49956
                                    elm.setIsComplete("TRUE");//sourceId:218938_2_49956
                                    return elm;
                                }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_49956
                    }

                    /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

                    bOOLEAN_4 = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_11)/*vcase invoke 本地 method 方法调用;*/;


                }
//ModelCode: circulationEnd
            }

        }
        ImplementUndoBatchHandleCheckItemStateComRespDto retData = new ImplementUndoBatchHandleCheckItemStateComRespDto();


        return retData;
    }

    /**
     * D3执行检查项状态等撤销批次恢复(公共)[7178]
     * gen by moon at 8/31/2023, 12:09:15 PM
     */
    @Trace(operationName = "D3执行检查项状态等撤销批次恢复(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCheckItemStateEtcDeleteBatchRecoverComRespDto implementCheckItemStateEtcDeleteBatchRecoverCom(ImplementCheckItemStateEtcDeleteBatchRecoverComReqDto reqDto) {


        //步骤0: M3执行接收字段入参（特殊方法） - implementAcceptField
        //ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
        ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setBatchSetObjectType(reqDto.getBatchSetObjectType());//SimpleFieldAssign//sourceId:1118275_1
            receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1118256_1
            receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1118257_1
            receptionServiceReq.setCustomField(reqDto.getAssumptionObjId());//SimpleFieldAssign//sourceId:1118258_1
            receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1118249_1
            receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1118248_1
            receptionServiceReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1118247_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118246_1
            receptionServiceReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1077698_1
            receptionServiceReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1077699_1
        }

        /*M3接收字段入参[6100]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getBatchSetObjectType(), "D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-批次设置对象类型不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjEntityId(), "D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-被评对象内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjTypeCode(), "D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-被评对象类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField(), "D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-自定义字段不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getObjectId(), "D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-归属对象内容ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUseTypeCode(), "D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-用途类型编码不能为空", false);
        receptionServiceRes = nbResetCheckItemState.implementAcceptField(receptionServiceReq);


//步骤1: D3执行撤销批次处理状态检查项更新(公共) - implementUndoBatchHandleCheckItemStateCom
        ImplementUndoBatchHandleCheckItemStateComRespDto implementUndoBatchHandleCheckItemStateComRespDto = null;
        ImplementUndoBatchHandleCheckItemStateComReqDto implementUndoBatchHandleCheckItemStateComReqDto = new ImplementUndoBatchHandleCheckItemStateComReqDto();
        if (reqDto != null) {
            implementUndoBatchHandleCheckItemStateComReqDto.setBatchSetObjectType(reqDto.getBatchSetObjectType());//SimpleFieldAssign//sourceId:1118274_1
            implementUndoBatchHandleCheckItemStateComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1118235_1
            implementUndoBatchHandleCheckItemStateComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1118236_1
            implementUndoBatchHandleCheckItemStateComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1118237_1
            implementUndoBatchHandleCheckItemStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118238_1
        }

        /*D3执行撤销批次处理状态检查项更新(公共)[7179]   */
        Assert.isNull(implementUndoBatchHandleCheckItemStateComReqDto.getBatchSetObjectType(), "D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次处理状态检查项更新(公共)-批次设置对象类型不能为空", false);
        Assert.isNull(implementUndoBatchHandleCheckItemStateComReqDto.getEvaluationTemplateId(), "D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次处理状态检查项更新(公共)-冗余评价模板ID不能为空", false);
        implementUndoBatchHandleCheckItemStateComRespDto = implementUndoBatchHandleCheckItemStateCom(implementUndoBatchHandleCheckItemStateComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤2: D3执行统计更新执行进度(公共) - implementStatisticsUpdateExecuteProgressCom
        ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
        ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto = new ImplementStatisticsUpdateExecuteProgressComReqDto();
        implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(Double.valueOf("10"));//CUSTOM_CONVENTION//sourceId:1077788_1
        if (reqDto != null) {
            implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1077789_1
            implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1077790_1
            implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1077791_1
        }

        /*D3更新执行进度(10%)[7094]   */
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(), "D3执行检查项状态等撤销批次恢复(公共)-D3更新执行进度(10%)-执行进度值不能为空", false);
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(), "D3执行检查项状态等撤销批次恢复(公共)-D3更新执行进度(10%)-归属对象内容ID不能为空", false);
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(), "D3执行检查项状态等撤销批次恢复(公共)-D3更新执行进度(10%)-用途类型编码不能为空", false);
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(), "D3执行检查项状态等撤销批次恢复(公共)-D3更新执行进度(10%)-主题内容ID不能为空", false);
        implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;


//步骤3: D3执行撤销批次高中基层刷新父子状态(公共) - implementUndoBatchTopMidBasicRefreshParentSonStateCom
        ImplementUndoBatchTopMidBasicRefreshParentSonStateComRespDto implementUndoBatchTopMidBasicRefreshParentSonStateComRespDto = null;
        ImplementUndoBatchTopMidBasicRefreshParentSonStateComReqDto implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto = new ImplementUndoBatchTopMidBasicRefreshParentSonStateComReqDto();
        implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1118244_1
        if (reqDto != null) {
            implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1118270_1
            implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1118271_1
            implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setAssumptionObjId(reqDto.getAssumptionObjId());//SimpleFieldAssign//sourceId:1118245_1
            implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118242_1
            implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1118241_1
            implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1118243_1
        }

        /*D3执行撤销批次高中基层刷新父子状态(公共)[7373]   */
        Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getEvaObjEntityId(), "D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getEvaObjTypeCode(), "D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getAssumptionObjId(), "D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-内容节点归属对象ID不能为空", false);
        Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getEvaluationTemplateId(), "D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getObjectId(), "D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getUseTypeCode(), "D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-用途类型编码不能为空", false);
        Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getExecuteProgressValue(), "D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-执行进度值不能为空", false);
        implementUndoBatchTopMidBasicRefreshParentSonStateComRespDto = implementUndoBatchTopMidBasicRefreshParentSonStateCom(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto)/*vcase invoke 同服务,同domain*/;


        ImplementCheckItemStateEtcDeleteBatchRecoverComRespDto retData = new ImplementCheckItemStateEtcDeleteBatchRecoverComRespDto();


        return retData;
    }

    /**
     * D3执行撤销批次处理仪表盘分子分母(公共)[7180]
     * gen by moon at 7/7/2023, 4:48:06 PM
     */
    @Trace(operationName = "D3执行撤销批次处理仪表盘分子分母(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementUndoBatchHandleDashBoardComRespDto implementUndoBatchHandleDashBoardCom(ImplementUndoBatchHandleDashBoardComReqDto reqDto) {


        //virtualUsage 3-11-02查模板下检查仪表盘列表  45049
        List<OmsAssistCheckPanelUpdate> listOmsAssistCheckPanelUpdate = new ArrayList<>();
        QueryCheckItemPanelListReq queryCheckItemPanelListReq = new QueryCheckItemPanelListReq();
        queryCheckItemPanelListReq.setIsSpecialSign("FALSE");//sourceId:1030515_1_45049
        if (reqDto != null) {
            queryCheckItemPanelListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1030514_1_45049
        }

        /*3-11-02查模板下检查仪表盘列表[2717]   */
        Assert.isNull(queryCheckItemPanelListReq.getThemeContentId(), "D3执行撤销批次处理仪表盘分子分母(公共)-3-11-02查模板下检查仪表盘列表-主题内容ID不能为空", false);
        Assert.isNull(queryCheckItemPanelListReq.getIsSpecialSign(), "D3执行撤销批次处理仪表盘分子分母(公共)-3-11-02查模板下检查仪表盘列表-是否特殊标记不能为空", false);
        listOmsAssistCheckPanelUpdate = mOmsAssistCheckPanelUpdateService.queryCheckItemPanelList(queryCheckItemPanelListReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage D3计算数据集单条进度值(公共)  46976
        ImplementCountDataSingleProgressComRespDto implementCountDataSingleProgressComRespDto = null;
        if (listOmsAssistCheckPanelUpdate != null && !CollectionUtil.isEmpty(listOmsAssistCheckPanelUpdate) && listOmsAssistCheckPanelUpdate.size() > 0) {
            ImplementCountDataSingleProgressComReqDto implementCountDataSingleProgressComReqDto = new ImplementCountDataSingleProgressComReqDto();
            if (listOmsAssistCheckPanelUpdate != null && !CollectionUtil.isEmpty(listOmsAssistCheckPanelUpdate) && listOmsAssistCheckPanelUpdate != null && !CollectionUtil.isEmpty(listOmsAssistCheckPanelUpdate)) {
                implementCountDataSingleProgressComReqDto.setCountNumberDataSetsList(listOmsAssistCheckPanelUpdate.stream().map(item -> item.getCheckItemPanelUpdateId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1077760_1_46976
            }
            if (reqDto != null) {
                implementCountDataSingleProgressComReqDto.setCalcPara1(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1077762_1_46976
            }

            /*D3计算数据集单条进度值(公共)[6561]   */
            Assert.isNull(implementCountDataSingleProgressComReqDto.getCalcPara1(), "D3执行撤销批次处理仪表盘分子分母(公共)-D3计算数据集单条进度值(公共)-被除数值不能为空", false);
            implementCountDataSingleProgressComRespDto = progressPublicTechnicaCapacityService.implementCountDataSingleProgressCom(implementCountDataSingleProgressComReqDto)/*vcase invoke isSameApp*/;


        }
//virtualUsage M3-仪表盘发牌【循环开始】  45050
        //ModelCode: circulationCollections
        for (OmsAssistCheckPanelUpdate circulationCollectionsRes : listOmsAssistCheckPanelUpdate) {

//virtualUsage D4-分母减分子  45052
            CalculateSubtractionOfTwoNumServiceComRespDto calculateSubtractionOfTwoNumServiceComRespDto = null;
            CalculateSubtractionOfTwoNumServiceComReqDto calculateSubtractionOfTwoNumServiceComReqDto = new CalculateSubtractionOfTwoNumServiceComReqDto();
            if (circulationCollectionsRes != null) {
                calculateSubtractionOfTwoNumServiceComReqDto.setCalcPara1(circulationCollectionsRes.getTargetValue() != null ? Double.valueOf(circulationCollectionsRes.getTargetValue()) : null);//SimpleFieldAssign//sourceId:1030520_1_45052
                calculateSubtractionOfTwoNumServiceComReqDto.setCalcPara2(circulationCollectionsRes.getActualValue() != null ? Double.valueOf(circulationCollectionsRes.getActualValue()) : null);//SimpleFieldAssign//sourceId:1030521_1_45052
            }

            /*D4-分母减分子[3365]   */

            calculateSubtractionOfTwoNumServiceComRespDto = fwCalcCalculationRulesClient.calculateSubtractionOfTwoNumServiceCom(calculateSubtractionOfTwoNumServiceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((calculateSubtractionOfTwoNumServiceComRespDto != null && calculateSubtractionOfTwoNumServiceComRespDto.getCalcResult() > 0)) {
                //if(D4-分母减分子.计算结果 大于 0)  45053

                boolean bOOLEAN;
                OmsAssistCheckPanelUpdate omsAssistCheckPanelUpdate = new OmsAssistCheckPanelUpdate();
                if (circulationCollectionsRes != null) {
                    omsAssistCheckPanelUpdate.setCheckItemPanelUpdateId(circulationCollectionsRes.getCheckItemPanelUpdateId());//SimpleFieldAssign//sourceId:1030506_1_45054
                    omsAssistCheckPanelUpdate.setActualValue(circulationCollectionsRes.getTargetValue());//SimpleFieldAssign//sourceId:1030507_1_45054
                }

                /*3-11-02修改检查仪表盘更新[320]   */
                Assert.isNull(omsAssistCheckPanelUpdate.getCheckItemPanelUpdateId(), "D3执行撤销批次处理仪表盘分子分母(公共)-3-11-02修改检查仪表盘更新-检查仪表盘更新记录ID 不能为空", false);
                Assert.isNull(omsAssistCheckPanelUpdate.getActualValue(), "D3执行撤销批次处理仪表盘分子分母(公共)-3-11-02修改检查仪表盘更新-实际数值不能为空", false);
                bOOLEAN = mOmsAssistCheckPanelUpdateService.updateAssistCheckPanelUpdate(omsAssistCheckPanelUpdate)/*vcase invoke 本地 method 方法调用;*/;


            }
//virtualUsage D3更新执行进度(计算单条进度值结果)  46977
            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
            if (implementCountDataSingleProgressComRespDto != null) {
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                if (implementCountDataSingleProgressComRespDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(implementCountDataSingleProgressComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1077713_1_46977
                }
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1077714_1_46977
                    implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1077715_1_46977
                    implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1077716_1_46977
                }

                /*D3更新执行进度(计算单条进度值结果)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(), "D3执行撤销批次处理仪表盘分子分母(公共)-D3更新执行进度(计算单条进度值结果)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(), "D3执行撤销批次处理仪表盘分子分母(公共)-D3更新执行进度(计算单条进度值结果)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(), "D3执行撤销批次处理仪表盘分子分母(公共)-D3更新执行进度(计算单条进度值结果)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(), "D3执行撤销批次处理仪表盘分子分母(公共)-D3更新执行进度(计算单条进度值结果)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;


            }
//virtualUsage M3-执行【循环结束】  45051
            //ModelCode: circulationEnd
        }

        ImplementUndoBatchHandleDashBoardComRespDto retData = new ImplementUndoBatchHandleDashBoardComRespDto();


        return retData;
    }

    /**
     * D3执行撤销批次处理内容节点状态更新(公共)[7181]
     * gen by moon at 6/11/2023, 6:43:02 AM
     */
    @Trace(operationName = "D3执行撤销批次处理内容节点状态更新(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementUndoBatchHandleParentSubStateStateComRespDto implementUndoBatchHandleParentSubStateStateCom(ImplementUndoBatchHandleParentSubStateStateComReqDto reqDto) {


        //步骤0: 3-11-01查内容节点状态列表 - queryAssistNodeStatusList
        List<OmsAssistNodeStatus> listOmsAssistNodeStatus = new ArrayList<>();
        QueryAssistNodeStatusListReq queryAssistNodeStatusListReq = new QueryAssistNodeStatusListReq();
        queryAssistNodeStatusListReq.setCurrentLevelComplete("FALSE");//sourceId:1030309_1
        if (reqDto != null) {
            queryAssistNodeStatusListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1030306_1
        }

        /*3-11-01查批次下本级未完成的内容节点状态列表[318]   */
        Assert.isNull(queryAssistNodeStatusListReq.getThemeContentId(), "D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查批次下本级未完成的内容节点状态列表-主题内容ID不能为空", false);
        Assert.isNull(queryAssistNodeStatusListReq.getCurrentLevelComplete(), "D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查批次下本级未完成的内容节点状态列表-是否本级完成不能为空", false);
        listOmsAssistNodeStatus = mOmsAssistNodeStatusService.queryAssistNodeStatusList(queryAssistNodeStatusListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-11-01批量改内容节点状态 - batchUpdateAssistNodeStatus
        boolean bOOLEAN;
        if (listOmsAssistNodeStatus != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus) && listOmsAssistNodeStatus.size() > 0) {
            List<OmsAssistNodeStatus> listOmsAssistNodeStatus_2 = new ArrayList<>();
            if (listOmsAssistNodeStatus != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus) && listOmsAssistNodeStatus != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus)) {
                listOmsAssistNodeStatus_2 = //objList-to-objLists
                        listOmsAssistNodeStatus.stream().map(item -> {
                            OmsAssistNodeStatus elm = new OmsAssistNodeStatus();
                            elm.setAssistNodeStatusId(item.getAssistNodeStatusId());//SimpleFieldAssign//sourceId:218983_2
                            elm.setCurNodeDoneNum(item.getCurNodeNum());//SimpleFieldAssign//sourceId:218984_2
                            elm.setCurrentLevelComplete("TRUE");//sourceId:218985_2
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030311_1
            }

            /*3-11-01批量改内容节点状态本级已完成及本级完成数量[2774]   */

            bOOLEAN = mOmsAssistNodeStatusService.batchUpdateAssistNodeStatus(listOmsAssistNodeStatus_2)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤2: 3-11-01查内容节点状态列表 - queryAssistNodeStatusList
        List<OmsAssistNodeStatus> listOmsAssistNodeStatus_3 = new ArrayList<>();
        QueryAssistNodeStatusListReq queryAssistNodeStatusListReq_1 = new QueryAssistNodeStatusListReq();
        queryAssistNodeStatusListReq_1.setNextLevelComplete("FALSE");//sourceId:1030312_1
        if (reqDto != null) {
            queryAssistNodeStatusListReq_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1030313_1
        }

        /*3-11-01查批次下下级未完成的内容节点状态列表[318]   */
        Assert.isNull(queryAssistNodeStatusListReq_1.getThemeContentId(), "D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查批次下下级未完成的内容节点状态列表-主题内容ID不能为空", false);
        Assert.isNull(queryAssistNodeStatusListReq_1.getNextLevelComplete(), "D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查批次下下级未完成的内容节点状态列表-是否下级完成不能为空", false);
        listOmsAssistNodeStatus_3 = mOmsAssistNodeStatusService.queryAssistNodeStatusList(queryAssistNodeStatusListReq_1)/*vcase invoke 本地 method 方法调用;*/;


//步骤3: 3-11-01批量改内容节点状态 - batchUpdateAssistNodeStatus
        boolean bOOLEAN_1;
        if (listOmsAssistNodeStatus_3 != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus_3) && listOmsAssistNodeStatus_3.size() > 0) {
            List<OmsAssistNodeStatus> listOmsAssistNodeStatus_5 = new ArrayList<>();
            if (listOmsAssistNodeStatus_3 != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus_3) && listOmsAssistNodeStatus_3 != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus_3)) {
                listOmsAssistNodeStatus_5 = //objList-to-objLists
                        listOmsAssistNodeStatus_3.stream().map(item -> {
                            OmsAssistNodeStatus elm = new OmsAssistNodeStatus();
                            elm.setAssistNodeStatusId(item.getAssistNodeStatusId());//SimpleFieldAssign//sourceId:219081_2
                            elm.setCurNodeDoneNum(item.getNextNodeNum());//SimpleFieldAssign//sourceId:219082_2
                            elm.setNextLevelComplete("TRUE");//sourceId:219083_2
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030502_1
            }

            /*3-11-01批量改内容节点状态下级级已完成及下级完成数量[2774]   */

            bOOLEAN_1 = mOmsAssistNodeStatusService.batchUpdateAssistNodeStatus(listOmsAssistNodeStatus_5)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤4: 3-11-01查内容节点状态列表 - queryAssistNodeStatusList
        List<OmsAssistNodeStatus> listOmsAssistNodeStatus_6 = new ArrayList<>();
        QueryAssistNodeStatusListReq queryAssistNodeStatusListReq_2 = new QueryAssistNodeStatusListReq();
        queryAssistNodeStatusListReq_2.setIsComplete("FALSE");//sourceId:1030503_1
        if (reqDto != null) {
            queryAssistNodeStatusListReq_2.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1030504_1
        }

        /*3-11-01查当前批次下全部未完成的内容节点状态列表[318]   */
        Assert.isNull(queryAssistNodeStatusListReq_2.getThemeContentId(), "D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查当前批次下全部未完成的内容节点状态列表-主题内容ID不能为空", false);
        Assert.isNull(queryAssistNodeStatusListReq_2.getIsComplete(), "D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查当前批次下全部未完成的内容节点状态列表-是否已完成不能为空", false);
        listOmsAssistNodeStatus_6 = mOmsAssistNodeStatusService.queryAssistNodeStatusList(queryAssistNodeStatusListReq_2)/*vcase invoke 本地 method 方法调用;*/;


//步骤5: 3-11-01批量改内容节点状态 - batchUpdateAssistNodeStatus
        boolean bOOLEAN_2;
        if (listOmsAssistNodeStatus_6 != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus_6) && listOmsAssistNodeStatus_6.size() > 0) {
            List<OmsAssistNodeStatus> listOmsAssistNodeStatus_8 = new ArrayList<>();
            if (listOmsAssistNodeStatus_6 != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus_6) && listOmsAssistNodeStatus_6 != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus_6)) {
                listOmsAssistNodeStatus_8 = listOmsAssistNodeStatus_6.stream().map(item -> {
                    OmsAssistNodeStatus elm = BeanUtil.toBean(item, OmsAssistNodeStatus.class);
                    elm.setIsComplete("TRUE");

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030505_1
            }

            /*3-11-01批量改内容节点状态全部已完成[2774]   */

            bOOLEAN_2 = mOmsAssistNodeStatusService.batchUpdateAssistNodeStatus(listOmsAssistNodeStatus_8)/*vcase invoke 本地 method 方法调用;*/;


        }

        ImplementUndoBatchHandleParentSubStateStateComRespDto retData = new ImplementUndoBatchHandleParentSubStateStateComRespDto();


        return retData;
    }

    /**
     * D3执行撤销批次高中基层刷新父子状态(公共)[7373]
     * gen by moon at 8/31/2023, 11:55:13 AM
     */
    @Trace(operationName = "D3执行撤销批次高中基层刷新父子状态(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementUndoBatchTopMidBasicRefreshParentSonStateComRespDto implementUndoBatchTopMidBasicRefreshParentSonStateCom(ImplementUndoBatchTopMidBasicRefreshParentSonStateComReqDto reqDto) {


        //virtualUsage 3-11-01查父子状态内容范围  48392
        List<OmsAssistNodeStatus> listOmsAssistNodeStatus = new ArrayList<>();
        ImplementAssistNodeStatusByCodeOrderReq implementAssistNodeStatusByCodeOrderReq = new ImplementAssistNodeStatusByCodeOrderReq();
        implementAssistNodeStatusByCodeOrderReq.setEmploySceneTypeCode("USED_TARGET_CONTNET_SET");//sourceId:1117799_1_48392
        implementAssistNodeStatusByCodeOrderReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1117801_1_48392
        if (reqDto != null) {
            implementAssistNodeStatusByCodeOrderReq.setObjectId(reqDto.getAssumptionObjId());//SimpleFieldAssign//sourceId:1117798_1_48392
            implementAssistNodeStatusByCodeOrderReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1117800_1_48392
        }

        /*3-11-01查父子状态内容范围[6571]   */
        Assert.isNull(implementAssistNodeStatusByCodeOrderReq.getObjectId(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-11-01查父子状态内容范围-归属对象内容ID不能为空", false);
        Assert.isNull(implementAssistNodeStatusByCodeOrderReq.getThemeContentId(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-11-01查父子状态内容范围-主题内容ID不能为空", false);
        Assert.isNull(implementAssistNodeStatusByCodeOrderReq.getEmploySceneTypeCode(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-11-01查父子状态内容范围-使用场景编码不能为空", false);
        Assert.isNull(implementAssistNodeStatusByCodeOrderReq.getSpaceId(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-11-01查父子状态内容范围-创建于空间ID不能为空", false);
        listOmsAssistNodeStatus = mOmsAssistNodeStatusService.implementAssistNodeStatusByCodeOrder(implementAssistNodeStatusByCodeOrderReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-3-09批量查内容目标父周期范围  48393
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        if (listOmsAssistNodeStatus != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus) && listOmsAssistNodeStatus.size() > 0) {
            ImplementContentMatchTargetCycleCodeOrderReq implementContentMatchTargetCycleCodeOrderReq = new ImplementContentMatchTargetCycleCodeOrderReq();
            implementContentMatchTargetCycleCodeOrderReq.setIsParentCycle("TRUE");//sourceId:1117806_1_48393
            implementContentMatchTargetCycleCodeOrderReq.setIsArchive("FALSE");//sourceId:1117809_1_48393
            implementContentMatchTargetCycleCodeOrderReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1117810_1_48393
            if (listOmsAssistNodeStatus != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus) && listOmsAssistNodeStatus != null && !CollectionUtil.isEmpty(listOmsAssistNodeStatus)) {
                implementContentMatchTargetCycleCodeOrderReq.setEvaObjTargetCycleList(listOmsAssistNodeStatus.stream().map(item -> item.getAssistNodeTypeObjectId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1117803_1_48393
            }
            if (reqDto != null) {
                implementContentMatchTargetCycleCodeOrderReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1117804_1_48393
                implementContentMatchTargetCycleCodeOrderReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1117805_1_48393
                implementContentMatchTargetCycleCodeOrderReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1117807_1_48393
            }

            /*3-3-09批量查内容目标父周期范围[6573]   */
            Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getEvaObjEntityId(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-被评对象内容表主键ID不能为空", false);
            Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getEvaObjTypeCode(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-被评对象类型编码不能为空", false);
            Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getIsParentCycle(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-是否父周期不能为空", false);
            Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getEvaluationTemplateId(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-冗余评价模板ID不能为空", false);
            Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getIsArchive(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-是否存档不能为空", false);
            Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getSpaceId(), "D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-创建于空间ID不能为空", false);
            listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.implementContentMatchTargetCycleCodeOrder(implementContentMatchTargetCycleCodeOrderReq)/*vcase invoke 本地 method 方法调用;*/;


        }
//virtualUsage D3计算数据集单条进度值(公共)  48394
        ImplementCountDataSingleProgressComRespDto implementCountDataSingleProgressComRespDto = null;
        if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle.size() > 0) {
            ImplementCountDataSingleProgressComReqDto implementCountDataSingleProgressComReqDto = new ImplementCountDataSingleProgressComReqDto();
            if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)) {
                implementCountDataSingleProgressComReqDto.setCountNumberDataSetsList(listOmsEvaluationObjectTargetCycle.stream().map(item -> item.getEvaObjTargetCycleId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1117769_1_48394
            }
            if (reqDto != null) {
                implementCountDataSingleProgressComReqDto.setCalcPara1(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1117771_1_48394
            }

            /*D3计算数据集单条进度值(公共)[6561]   */
            Assert.isNull(implementCountDataSingleProgressComReqDto.getCalcPara1(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3计算数据集单条进度值(公共)-被除数值不能为空", false);
            implementCountDataSingleProgressComRespDto = progressPublicTechnicaCapacityService.implementCountDataSingleProgressCom(implementCountDataSingleProgressComReqDto)/*vcase invoke isSameApp*/;


        }
//virtualUsage M3目标周期发牌【循环开始】  48395
        //ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes : listOmsEvaluationObjectTargetCycle) {

//virtualUsage D3执行发单牌仪表盘父子状态(公共)  48398
            ImplementIssueSingleCardUpdateDashboardParentChildStatusComRespDto implementIssueSingleCardUpdateDashboardParentChildStatusComRespDto = null;
            ImplementIssueSingleCardUpdateDashboardParentChildStatusComReqDto implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto = new ImplementIssueSingleCardUpdateDashboardParentChildStatusComReqDto();
            implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEmploySceneTypeCode("USED_TARGET_CONTNET_SET");//sourceId:1117789_1_48398
            if (circulationCollectionsRes != null) {
                implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1117780_1_48398
                implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaObjTargetCycleCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1117781_1_48398
                implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1117782_1_48398
                implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaObjTypeCode(circulationCollectionsRes.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1117783_1_48398
                implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1117784_1_48398
                implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1117785_1_48398
                implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setTargetId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:1117786_1_48398
                implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setIsUseFirstDept(circulationCollectionsRes.getIsUseFirstDept());//SimpleFieldAssign//sourceId:1117788_1_48398
            }
            if (reqDto != null) {
                implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1117787_1_48398
            }

            /*D3执行发单牌仪表盘父子状态(公共)[5858]   */
            Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEvaObjTargetCycleCode(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-被评对象目标周期标识不能为空", false);
            Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEvaObjEntityId(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-被评对象内容表主键ID不能为空", false);
            Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEvaObjTypeCode(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-被评对象类型编码不能为空", false);
            Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getTargetCycleContentTypeCode(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-关联目标内容类型编码不能为空", false);
            Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getTargetCycleContentId(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getTargetId(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-冗余目标ID不能为空", false);
            Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEvaluationTemplateId(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEmploySceneTypeCode(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-使用场景编码不能为空", false);
            implementIssueSingleCardUpdateDashboardParentChildStatusComRespDto = targetContentService.implementIssueSingleCardUpdateDashboardParentChildStatusCom(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D3执行统计更新执行进度(公共)  48399
            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
            if (implementCountDataSingleProgressComRespDto != null) {
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                if (implementCountDataSingleProgressComRespDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(implementCountDataSingleProgressComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1117772_1_48399
                }
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1117774_1_48399
                    implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1117775_1_48399
                    implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1117776_1_48399
                }

                /*D3执行统计更新执行进度(公共)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行统计更新执行进度(公共)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行统计更新执行进度(公共)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行统计更新执行进度(公共)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(), "D3执行撤销批次高中基层刷新父子状态(公共)-D3执行统计更新执行进度(公共)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;


            }
//virtualUsage M3-执行【循环结束】  48396
            //ModelCode: circulationEnd
        }

        ImplementUndoBatchTopMidBasicRefreshParentSonStateComRespDto retData = new ImplementUndoBatchTopMidBasicRefreshParentSonStateComRespDto();


        return retData;
    }
    //
}
